"""
TabletService MNE每秒处理方法
文件功能：为TabletService提供MNE每秒独立处理的方法
处理原理：对每秒的脑波数据独立进行MNE滤波处理，不依赖于时间切块
使用方法：通过_perform_mne_processing_per_second方法对所有会话数据进行逐秒MNE处理
"""

import logging
from typing import Dict, List, Any
import numpy as np
from datetime import datetime, timedelta

from ..models.brain_wave_data import BrainWaveData, FrequencyData, TimeSeriesData

logger = logging.getLogger(__name__)

class MNEPerSecondProcessor:
    """MNE每秒处理器"""
    
    def __init__(self, mne_processor):
        """
        初始化MNE每秒处理器
        
        Args:
            mne_processor: MNE处理器实例
        """
        self.mne_processor = mne_processor
        self._processed_cache = {}  # 缓存已处理的数据
    
    async def process_session_data_per_second(self, session_id: str, session_data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """
        对会话数据进行每秒独立的MNE处理
        
        功能：
        1. 对每秒的数据独立进行MNE滤波
        2. 缓存已处理的数据，避免重复处理
        3. 只处理新增的数据
        
        Args:
            session_id: 会话ID
            session_data: 会话的所有数据点
            
        Returns:
            List[Dict[str, Any]]: MNE处理后的数据列表
        """
        try:
            # 获取缓存的处理结果
            cached_data = self._processed_cache.get(session_id, [])
            cached_count = len(cached_data)
            
            # 只处理新增的数据
            new_data = session_data[cached_count:] if cached_count < len(session_data) else []
            
            if not new_data:
                logger.debug(f"会话 {session_id} 无新数据需要MNE处理")
                return cached_data
            
            logger.info(f"开始MNE每秒处理: session_id={session_id}, 新数据点={len(new_data)}, 缓存数据点={cached_count}")
            
            # 对新数据进行MNE处理
            processed_new_data = []
            for data_point in new_data:
                try:
                    # 转换为BrainWaveData对象
                    brain_wave_data = self._convert_to_brain_wave_data(data_point)
                    
                    # MNE处理单个数据点
                    filtered_data = await self.mne_processor.process_single_sample(brain_wave_data)
                    
                    # 转换回字典格式
                    processed_dict = self._brain_wave_to_dict(filtered_data)
                    processed_new_data.append(processed_dict)
                    
                except Exception as e:
                    logger.warning(f"MNE处理单个数据点失败: {str(e)}")
                    # 使用原始数据
                    processed_new_data.append(data_point)
            
            # 更新缓存
            all_processed_data = cached_data + processed_new_data
            self._processed_cache[session_id] = all_processed_data
            
            logger.info(f"MNE每秒处理完成: session_id={session_id}, 总处理数据点={len(all_processed_data)}")
            return all_processed_data
            
        except Exception as e:
            logger.error(f"MNE每秒处理异常: session_id={session_id}, error={str(e)}", exc_info=True)
            # 返回原始数据
            return session_data
    
    def _convert_to_brain_wave_data(self, data_point: Dict[str, Any]) -> BrainWaveData:
        """
        将数据点转换为BrainWaveData对象
        
        Args:
            data_point: 原始数据点
            
        Returns:
            BrainWaveData: 转换后的脑波数据对象
        """
        frequency_data = data_point['frequency_data']
        
        # 处理raw_value数据
        raw_value = data_point['raw_value']
        if hasattr(raw_value, 'value'):
            # 如果是RawValuePoint对象，提取value属性
            raw_data = np.array([float(raw_value.value)])
        elif isinstance(raw_value, list):
            # 如果是RawValuePoint对象列表，提取所有value
            raw_data = np.array([float(point.value) if hasattr(point, 'value') else float(point) for point in raw_value])
        else:
            # 如果是普通数值
            raw_data = np.array([float(raw_value)])
        
        # 创建TimeSeriesData对象
        time_series = TimeSeriesData(
            data=raw_data,
            sampling_rate=512,  # 默认采样率
            timestamp=data_point['timestamp'],
            channel_names=['EEG']
        )
        
        brain_wave_data = BrainWaveData(
            time_series=time_series,
            frequency_data=frequency_data,
            session_id=data_point['session_id'],
            room_id=data_point.get('room_id', ''),
            processing_stage="raw"
        )
        
        return brain_wave_data
    
    def _brain_wave_to_dict(self, brain_wave_data: BrainWaveData) -> Dict[str, Any]:
        """
        将BrainWaveData对象转换为字典格式
        
        Args:
            brain_wave_data: 脑波数据对象
            
        Returns:
            Dict[str, Any]: 字典格式的数据
        """
        # 获取完整的时间序列数据，而不是只取第一个值
        # 这对于YASA分析至关重要，因为YASA需要完整的时间序列数据
        raw_value_data = brain_wave_data.time_series.data if len(brain_wave_data.time_series.data) > 0 else np.array([0])
        
        return {
            'session_id': brain_wave_data.session_id,
            'room_id': brain_wave_data.room_id,
            'timestamp': brain_wave_data.time_series.timestamp,
            'raw_value': raw_value_data,  # 传递完整的时间序列数据
            'processed_raw_value': raw_value_data,  # 同样传递完整数据
            'frequency_data': brain_wave_data.frequency_data,
            'processing_stage': brain_wave_data.processing_stage
        }
    
    def clear_cache(self, session_id: str = None):
        """
        清理缓存
        
        Args:
            session_id: 指定会话ID，如果为None则清理所有缓存
        """
        if session_id:
            self._processed_cache.pop(session_id, None)
            logger.info(f"已清理会话 {session_id} 的MNE处理缓存")
        else:
            self._processed_cache.clear()
            logger.info("已清理所有MNE处理缓存")